home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / dev / c / vbcc.lha / vbcc / supp.c < prev    next >
C/C++ Source or Header  |  1997-12-30  |  13KB  |  417 lines
  1. #include "supp.h"
  2.  
  3. static char FILE_[]=__FILE__;
  4.  
  5. char *typname[]={"strange","char","short","int","long","float","double","void",
  6.                  "pointer","array","struct","union","enum","function"};
  7. char *storage_class_name[]={"strange","auto","register","static","extern","typedef"};
  8.  
  9. char *ename[]={"strange","sequence","move","set+","set-","set*","set/","set%",
  10.                "set&","set^","set|","set<<","set>>","?:","lor","land","or",
  11.                "eor","and","equal","unequal","lt","le","gt","ge","lsl",
  12.                "lsr","add","sub","mul","div","mod","negate",
  13.                "not","preinc","postinc","predec","postdec","neg",
  14.                "dref-pointer","address-of","cast","call","index",
  15.                "dref-struct-pointer","dref-struct","identifier","constant",
  16.                "string","member",
  17.                 "convert-char","convert-short","convert-int","convert-long",
  18.                 "convert-float","convert-double","convert-void","convert-pointer",
  19.                 "convert-uchar","convert-ushort","convert-uint","convert-ulong",
  20.                 "address-of-array","first-element-of-array","pmult",
  21.                 "allocreg","freereg","pconstant","test","label","beq","bne",
  22.                 "blt","bge","ble","bgt","bra","compare","push","pop",
  23.                 "address-of-struct","add-int-to-pointer","sub-int-from-pointer",
  24.                 "sub-pointer-from-pointer","push-reg","pop-reg","pop-args",
  25.                 "save-regs","restore-regs","identifier-label","dc","align",
  26.                 "colon","get-return","set-return","move-from-reg","move-to-reg",
  27.                 "nop"};
  28.  
  29. char *empty="";
  30. zchar vchar; zuchar vuchar;
  31. zshort vshort; zushort vushort;
  32. zint vint; zuint vuint;
  33. zlong vlong; zulong vulong;
  34. zfloat vfloat; zdouble vdouble;
  35. zpointer vpointer;
  36.  
  37. #ifndef DEBUG
  38. int DEBUG;
  39. #endif
  40.  
  41. int label;
  42.  
  43. int regs[MAXR+1],regused[MAXR+1];
  44. struct Var *regsv[MAXR+1];
  45. int goto_used;
  46. int ic_count;
  47. zlong max_offset;
  48. int function_calls;
  49. int multiple_ccs;
  50. int lastlabel,return_label;
  51. int only_inline;
  52. struct IC *err_ic;
  53. long maxoptpasses=10;
  54. long optflags;
  55. long inline_size=100;
  56. long unroll_size=200;
  57. long fp_assoc,noaliasopt;
  58. int fline;
  59. char errfname[FILENAME_MAX+1];
  60. struct IC *first_ic,*last_ic;
  61. int float_used;
  62. /*  Das haette ich gern woanders    */
  63. struct Var *vl1,*vl2,*vl3;
  64.  
  65.  
  66. struct Typ *clone_typ(struct Typ *old)
  67. /*  Erzeugt Kopie eines Typs und liefert Zeiger auf Kopie.  */
  68. {
  69.   struct Typ *new;
  70.   if(!old) return(0);
  71.   new=mymalloc(TYPS);
  72.   *new=*old;
  73.   if(new->next) new->next=clone_typ(new->next);
  74.   return(new);
  75. }
  76. void free_IC(struct IC *p)
  77. /*  Gibt IC-Liste inkl. Typen frei.                 */
  78. {
  79.   struct IC *merk;
  80.   if(DEBUG&1) printf("free_IC()\n");
  81.   while(p){
  82.     if(p->q1.am) free(p->q1.am);
  83.     if(p->q2.am) free(p->q2.am);
  84.     if(p->z.am) free(p->z.am);
  85.     merk=p->next;
  86.     free(p);
  87.     p=merk;
  88.   }
  89. }
  90. void remove_IC(struct IC *p)
  91. /*  Entfernt IC p aus Liste. */
  92. {
  93.   if(p->prev) p->prev->next=p->next; else first_ic=p->next;
  94.   if(p->next) p->next->prev=p->prev; else last_ic=p->prev;
  95.   if(p->q1.am) free(p->q1.am);
  96.   if(p->q2.am) free(p->q2.am);
  97.   if(p->z.am) free(p->z.am);
  98.   free(p);
  99. }
  100. void freetyp(struct Typ *p)
  101. /* Gibt eine Typ-Liste frei, aber keine struct_declaration oder so. */
  102. {
  103.   int f;struct Typ *merk;
  104.   if(DEBUG&8){printf("freetyp: ");prd(stdout,p);printf("\n");}
  105.   while(p){
  106.     merk=p->next;
  107.     f=p->flags&NQ;
  108.     if(merk&&f!=ARRAY&&f!=POINTER&&f!=FUNKT){ierror(0);return;}
  109.     free(p);
  110.     p=merk;
  111.   }
  112. }
  113. zlong falign(struct Typ *t)
  114. /*  Liefert Alignment eines Typs. Funktioniert im Gegensatz zum  */
  115. /*  align[]-Array auch mit zusammengesetzten Typen.              */
  116. {
  117.   int i,f; zlong al,alt;
  118.   f=t->flags&NQ;
  119.   al=align[f];
  120.   if(f<=POINTER) return al;
  121.   if(f==ARRAY){
  122.     do{ 
  123.       t=t->next; 
  124.       f=t->flags&NQ;
  125.     }while(f==ARRAY);
  126.     alt=falign(t);
  127.     if(zlleq(al,alt)) return alt; else return al;
  128.   }
  129.   if(f==UNION||f==STRUCT){
  130.     for(i=0;i<t->exact->count;i++){
  131.       alt=falign((*t->exact->sl)[i].styp);
  132.       if(!zlleq(alt,al)) al=alt;
  133.     }
  134.     return al;
  135.   }
  136.   return al;
  137. }
  138. zlong szof(struct Typ *t)
  139. /*  Liefert die benoetigte Groesse eines Typs in Bytes.     */
  140. {
  141.   int i=t->flags&NQ,j;zlong size,m;
  142.   if(i<=POINTER) return sizetab[i];
  143.   if(i==ARRAY){
  144.     size=zlmult((t->size),szof(t->next));
  145.     m=align[ARRAY];
  146.     return zlmult(zldiv(zladd(size,zlsub(m,l2zl(1L))),m),m); /* align */
  147.   }
  148.   if(i==UNION){
  149.     for(j=0,size=l2zl(0L);j<t->exact->count;j++){
  150.       m=szof((*t->exact->sl)[j].styp);
  151.       if(zleqto(m,l2zl(0L))) return(l2zl(0L));
  152.       if(!zlleq(m,size)) size=m;
  153.     }
  154.     m=falign(t);
  155.     return zlmult(zldiv(zladd(size,zlsub(m,l2zl(1L))),m),m); /* align */
  156.   }
  157.   if(i==STRUCT){
  158.     for(j=0,size=0;j<t->exact->count;j++){
  159.       struct Typ *h=(*t->exact->sl)[j].styp;
  160.       m=falign(h);
  161.       size=zlmult(zldiv(zladd(size,zlsub(m,l2zl(1L))),m),m);
  162.       m=szof(h);
  163.       if(zleqto(m,l2zl(0L))) return(l2zl(0L));
  164.       size=zladd(size,m);
  165.     }
  166.     m=falign(t);
  167.     return zlmult(zldiv(zladd(size,zlsub(m,l2zl(1L))),m),m); /* align */
  168.   }
  169.   return sizetab[i];
  170. }
  171. void printval(FILE *f,union atyps *p,int t,int verbose)
  172. /*  Gibt atyps aus.                                     */
  173. {
  174.   if(t==CHAR){if(verbose)fprintf(f,"C");vlong=zc2zl(p->vchar);printzl(f,vlong);}
  175.   if(t==(UNSIGNED|CHAR)){if(verbose)fprintf(f,"UC");vulong=zuc2zul(p->vuchar);printzul(f,vulong);}
  176.   if(t==SHORT){if(verbose)fprintf(f,"S");vlong=zs2zl(p->vshort);printzl(f,vlong);}
  177.   if(t==(UNSIGNED|SHORT)){if(verbose) fprintf(f,"US");vulong=zus2zul(p->vushort);printzul(f,vulong);}
  178.   if(t==FLOAT){if(verbose)fprintf(f,"F");vdouble=zf2zd(p->vfloat);printzd(f,vdouble);}
  179.   if(t==DOUBLE){if(verbose)fprintf(f,"D");printzd(f,p->vdouble);}
  180.   if(t==INT){if(verbose)fprintf(f,"I");vlong=zi2zl(p->vint);printzl(f,vlong);}
  181.   if(t==LONG){if(verbose)fprintf(f,"L");printzl(f,p->vlong);}
  182.   if(t==(UNSIGNED|INT)){if(verbose)fprintf(f,"UI");vulong=zui2zul(p->vuint);printzul(f,vulong);}
  183.   if(t==(UNSIGNED|LONG)){if(verbose)fprintf(f,"UL");printzul(f,p->vulong);}
  184.   /*  das hier ist nicht wirklich portabel    */
  185.   if(t==POINTER){if(verbose)fprintf(f,"P");vulong=zp2zul(p->vpointer);printzul(f,vulong);}
  186. }
  187. void pric2(FILE *f,struct IC *p)
  188. /*  Gibt ein IC aus.  */
  189. {
  190.   if(p->next&&p->next->prev!=p) ierror(0);
  191.   if(p->code>=LABEL&&p->code<=BRA){
  192.     if(p->code==LABEL)
  193.       fprintf(f,"L%d",p->typf);
  194.     else{
  195.       fprintf(f,"\t%s L%d",ename[p->code],p->typf);
  196.       if(p->q1.flags){ fprintf(f,",");probj(f,&p->q1,0);}
  197.     }
  198.   }else{
  199.     fprintf(f,"\t%s ",ename[p->code]);
  200.     if(p->typf&UNSIGNED) fprintf(f,"unsigned ");
  201.     if(p->typf) fprintf(f,"%s ",typname[p->typf&NQ]);
  202.     probj(f,&p->q1,p->typf);
  203.     if(p->q2.flags){fprintf(f,",");probj(f,&p->q2,p->typf);}
  204.     if(p->z.flags){fprintf(f,"->");probj(f,&p->z,p->typf);}
  205.     if(p->code==ASSIGN||p->code==PUSH||p->code==POP) fprintf(f," size=%ld",zl2l(p->q2.val.vlong));
  206.     if((p->code==SAVEREGS||p->code==RESTOREREGS)&&p->q1.reg) fprintf(f," except %s",regnames[p->q1.reg]);
  207.   }
  208.   fprintf(f,"\n");
  209. }
  210. void pric(FILE *f,struct IC *p)
  211. /*  Gibt IC-Liste auf dem Bildschirm aus.             */
  212. {
  213.   while(p){
  214.     pric2(f,p);
  215. /*        if(p->q1.am||p->q2.am||p->z.am) ierror(0);*/
  216.     p=p->next;
  217.   }
  218. }
  219. void printzl(FILE *f,zlong x)
  220. /*  Konvertiert zlong nach ASCII.                       */
  221. /*  Basiert noch einigermassen auf                      */
  222. /*  Zweierkomplementdarstellung (d.h. -MIN>MAX).        */
  223. /*  Ausserdem muss max(abs(long))<=max(unsigned long).  */
  224. {
  225.   zlong zl;zulong zul;
  226.   zl=l2zl(0L);
  227.   if(zlleq(x,zl)&&!zleqto(x,l2zl(0L))){
  228.     fprintf(f,"-");zl=zul2zl(t_max[LONG]);
  229.     if(zlleq(x,zlsub(l2zl(0L),zl))&&!zleqto(x,zlsub(l2zl(0L),zl))){
  230.       /*  aufpassen, da -x evtl. >LONG_MAX    */
  231.       zul=t_max[LONG];
  232.       x=zladd(x,zl);
  233.     } else zul=ul2zul(0UL);
  234.     x=zlsub(l2zl(0L),x);
  235.     vulong=zl2zul(x);
  236.     zul=zuladd(zul,vulong);
  237.   }else zul=zl2zul(x);
  238.   printzul(f,zul);
  239. }
  240. void printzul(FILE *f,zulong x)
  241. /*  Konvertiert zulong nach ASCII.                      */
  242. {
  243.   zulong zul;unsigned long l;
  244.   zul=ul2zul(10UL);
  245.   if(!zuleqto(zuldiv(x,zul),ul2zul(0UL))) printzul(f,zuldiv(x,zul));
  246.   zul=zulmod(x,zul);l=zul2ul(zul);
  247.   fprintf(f,"%c",(int)(l+'0'));
  248. }
  249. void printz